home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / hplip / base / logger.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  11.5 KB  |  349 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import thread
  6. import syslog
  7. import traceback
  8. import string
  9. import os
  10. identity = string.maketrans('', '')
  11. unprintable = identity.translate(identity, string.printable)
  12.  
  13. def printable(s):
  14.     return s.translate(identity, unprintable)
  15.  
  16. DEFAULT_LOG_LEVEL = 'info'
  17.  
  18. class Logger(object):
  19.     LOG_LEVEL_NONE = 99
  20.     LOG_LEVEL_FATAL = 40
  21.     LOG_LEVEL_ERROR = 30
  22.     LOG_LEVEL_WARN = 20
  23.     LOG_LEVEL_INFO = 10
  24.     LOG_LEVEL_DEBUG3 = 3
  25.     LOG_LEVEL_DBG3 = 3
  26.     LOG_LEVEL_DEBUG2 = 2
  27.     LOG_LEVEL_DBG2 = 2
  28.     LOG_LEVEL_DEBUG = 1
  29.     LOG_LEVEL_DBG = 1
  30.     logging_levels = {
  31.         'none': LOG_LEVEL_NONE,
  32.         'fata': LOG_LEVEL_FATAL,
  33.         'fatal': LOG_LEVEL_FATAL,
  34.         'erro': LOG_LEVEL_ERROR,
  35.         'error': LOG_LEVEL_ERROR,
  36.         'warn': LOG_LEVEL_WARN,
  37.         'info': LOG_LEVEL_INFO,
  38.         'debug': LOG_LEVEL_DEBUG,
  39.         'dbg': LOG_LEVEL_DEBUG,
  40.         'debug2': LOG_LEVEL_DEBUG2,
  41.         'dbg2': LOG_LEVEL_DEBUG2,
  42.         'debug3': LOG_LEVEL_DEBUG3,
  43.         'dbg3': LOG_LEVEL_DEBUG3 }
  44.     LOG_TO_DEV_NULL = 0
  45.     LOG_TO_CONSOLE = 1
  46.     LOG_TO_SCREEN = 1
  47.     LOG_TO_FILE = 2
  48.     LOG_TO_CONSOLE_AND_FILE = 3
  49.     LOG_TO_BOTH = 3
  50.     codes = { }
  51.     codes['reset'] = '\x1b[0m'
  52.     codes['bold'] = '\x1b[01m'
  53.     codes['teal'] = '\x1b[36;06m'
  54.     codes['turquoise'] = '\x1b[36;01m'
  55.     codes['fuscia'] = '\x1b[35;01m'
  56.     codes['purple'] = '\x1b[35;06m'
  57.     codes['blue'] = '\x1b[34;01m'
  58.     codes['darkblue'] = '\x1b[34;06m'
  59.     codes['green'] = '\x1b[32;01m'
  60.     codes['darkgreen'] = '\x1b[32;06m'
  61.     codes['yellow'] = '\x1b[33;01m'
  62.     codes['brown'] = '\x1b[33;06m'
  63.     codes['red'] = '\x1b[31;01m'
  64.     codes['darkred'] = '\x1b[31;06m'
  65.     
  66.     def __init__(self, module = '', level = LOG_LEVEL_INFO, where = LOG_TO_CONSOLE_AND_FILE, log_datetime = False, log_file = None):
  67.         self._where = where
  68.         self._log_file = log_file
  69.         self._log_file_f = None
  70.         self._log_datetime = log_datetime
  71.         self._lock = thread.allocate_lock()
  72.         self.module = module
  73.         self.pid = os.getpid()
  74.         self.fmt = True
  75.         self.set_level(level)
  76.  
  77.     
  78.     def set_level(self, level):
  79.         if isinstance(level, str):
  80.             level = level.lower()
  81.             if level in Logger.logging_levels.keys():
  82.                 self._level = Logger.logging_levels.get(level, Logger.LOG_LEVEL_INFO)
  83.                 return True
  84.             self.error('Invalid logging level: %s' % level)
  85.             return False
  86.         isinstance(level, str)
  87.         if isinstance(level, int):
  88.             if level <= level:
  89.                 pass
  90.             elif level <= Logger.LOG_LEVEL_FATAL:
  91.                 self._level = level
  92.             else:
  93.                 self._level = Logger.LOG_LEVEL_ERROR
  94.                 self.error('Invalid logging level: %d' % level)
  95.                 return False
  96.         level <= Logger.LOG_LEVEL_FATAL
  97.         return False
  98.  
  99.     
  100.     def set_module(self, module):
  101.         self.module = module
  102.         self.pid = os.getpid()
  103.  
  104.     
  105.     def no_formatting(self):
  106.         self.fmt = False
  107.  
  108.     
  109.     def set_logfile(self, log_file):
  110.         self._log_file = log_file
  111.         
  112.         try:
  113.             self._log_file_f = file(self._log_file, 'w')
  114.         except IOError:
  115.             self._log_file = None
  116.             self._log_file_f = None
  117.             self._where = Logger.LOG_TO_SCREEN
  118.  
  119.  
  120.     
  121.     def get_logfile(self):
  122.         return self._log_file
  123.  
  124.     
  125.     def set_where(self, where):
  126.         self._where = where
  127.  
  128.     
  129.     def get_level(self):
  130.         return self._level
  131.  
  132.     
  133.     def is_debug(self):
  134.         return self._level <= Logger.LOG_LEVEL_DEBUG3
  135.  
  136.     level = property(get_level, set_level)
  137.     
  138.     def log(self, message, level):
  139.         if self._where in (Logger.LOG_TO_CONSOLE, Logger.LOG_TO_CONSOLE_AND_FILE):
  140.             
  141.             try:
  142.                 self._lock.acquire()
  143.                 if level >= Logger.LOG_LEVEL_WARN:
  144.                     out = sys.stderr
  145.                 else:
  146.                     out = sys.stdout
  147.                 
  148.                 try:
  149.                     out.write(message)
  150.                 except UnicodeEncodeError:
  151.                     out.write(message.encode('utf-8'))
  152.  
  153.                 out.write('\n')
  154.             finally:
  155.                 self._lock.release()
  156.  
  157.         
  158.  
  159.     
  160.     def log_to_file(self, message):
  161.         if self._log_file_f is not None:
  162.             
  163.             try:
  164.                 self._lock.acquire()
  165.                 self._log_file_f.write(message.replace('\x1b', ''))
  166.                 self._log_file_f.write('\n')
  167.             finally:
  168.                 self._lock.release()
  169.  
  170.         
  171.  
  172.     
  173.     def stderr(self, message):
  174.         
  175.         try:
  176.             self._lock.acquire()
  177.             sys.stderr.write('%s: %s\n' % (self.module, message))
  178.         finally:
  179.             self._lock.release()
  180.  
  181.  
  182.     
  183.     def debug(self, message):
  184.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  185.             txt = '%s[%d]: debug: %s' % (self.module, self.pid, message)
  186.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG)
  187.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  188.                 self.log_to_file(txt)
  189.             
  190.         
  191.  
  192.     dbg = debug
  193.     
  194.     def debug2(self, message):
  195.         if self._level <= Logger.LOG_LEVEL_DEBUG2:
  196.             txt = '%s[%d]: debug2: %s' % (self.module, self.pid, message)
  197.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG2)
  198.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  199.                 self.log_to_file(txt)
  200.             
  201.         
  202.  
  203.     dbg2 = debug2
  204.     
  205.     def debug3(self, message):
  206.         if self._level <= Logger.LOG_LEVEL_DEBUG3:
  207.             txt = '%s[%d]: debug3: %s' % (self.module, self.pid, message)
  208.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG3)
  209.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  210.                 self.log_to_file(txt)
  211.             
  212.         
  213.  
  214.     dbg3 = debug3
  215.     
  216.     def debug_block(self, title, block):
  217.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  218.             line = '%s[%d]: debug: %s:' % (self.module, self.pid, title)
  219.             self.log(self.color(line, 'blue'), Logger.LOG_LEVEL_DEBUG)
  220.             self.log(self.color(block, 'blue'), Logger.LOG_LEVEL_DEBUG)
  221.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  222.                 self.log_to_file(line % (self.module, self.pid, title))
  223.                 self.log_to_file(block)
  224.             
  225.         
  226.  
  227.     printable = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~  '
  228.     
  229.     def log_data(self, data, width = 16):
  230.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  231.             if data:
  232.                 index = 0
  233.                 line = data[0:width]
  234.                 for d in line:
  235.                     txt = _[1](_[1]['%02x' % ord(d)])([
  236.                         ' ' * (width * 3 - 3 * len(line)),
  237.                         ''.join,
  238.                         [],
  239.                         []([ ('.', i)[i in Logger.printable] for i in line ])])
  240.                     self.log(self.color('%s[%d]: debug: %s' % (self.module, self.pid, txt), 'blue'), Logger.LOG_LEVEL_DEBUG)
  241.                     index += width
  242.                     line = data[index:index + width]
  243.                     []
  244.             else:
  245.                 self.log(self.color('%s[%d]: debug: %s' % (self.module, self.pid, '0000: (no data)'), 'blue'), Logger.LOG_LEVEL_DEBUG)
  246.         
  247.  
  248.     
  249.     def info(self, message = ''):
  250.         if self._level <= Logger.LOG_LEVEL_INFO:
  251.             self.log(message, Logger.LOG_LEVEL_INFO)
  252.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  253.                 self.log_to_file('%s[%d]: info: :%s' % (self.module, self.pid, message))
  254.             
  255.         
  256.  
  257.     information = info
  258.     
  259.     def warn(self, message):
  260.         if self._level <= Logger.LOG_LEVEL_WARN:
  261.             txt = 'warning: %s' % message.encode('utf-8')
  262.             self.log(self.color(txt, 'fuscia'), Logger.LOG_LEVEL_WARN)
  263.             syslog.syslog(syslog.LOG_WARNING, '%s[%d]: %s' % (self.module, self.pid, txt))
  264.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  265.                 self.log_to_file(txt)
  266.             
  267.         
  268.  
  269.     warning = warn
  270.     
  271.     def note(self, message):
  272.         if self._level <= Logger.LOG_LEVEL_WARN:
  273.             txt = 'note: %s' % message
  274.             self.log(self.color(txt, 'green'), Logger.LOG_LEVEL_WARN)
  275.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  276.                 self.log_to_file(txt)
  277.             
  278.         
  279.  
  280.     notice = note
  281.     
  282.     def error(self, message):
  283.         if self._level <= Logger.LOG_LEVEL_ERROR:
  284.             txt = 'error: %s' % message.encode('utf-8')
  285.             self.log(self.color(txt, 'red'), Logger.LOG_LEVEL_ERROR)
  286.             syslog.syslog(syslog.LOG_ALERT, '%s[%d]: %s' % (self.module, self.pid, txt))
  287.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  288.                 self.log_to_file(txt)
  289.             
  290.         
  291.  
  292.     
  293.     def fatal(self, message):
  294.         if self._level <= Logger.LOG_LEVEL_FATAL:
  295.             txt = 'fatal error: :%s' % self.module.encode('utf-8')
  296.             self.log(self.color(txt, 'red'), Logger.LOG_LEVEL_DEBUG)
  297.             syslog.syslog(syslog.LOG_ALERT, '%s[%d]: %s' % (self.module, self.pid, txt))
  298.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  299.                 self.log_to_file(txt)
  300.             
  301.         
  302.  
  303.     
  304.     def exception(self):
  305.         (typ, value, tb) = sys.exc_info()
  306.         body = 'Traceback (innermost last):\n'
  307.         lst = traceback.format_tb(tb) + traceback.format_exception_only(typ, value)
  308.         body = body + '%-20s %s' % (''.join(lst[:-1]), lst[-1])
  309.         self.fatal(body)
  310.  
  311.     
  312.     def color(self, text, color):
  313.         if self.fmt:
  314.             return ''.join([
  315.                 Logger.codes.get(color, 'bold'),
  316.                 text,
  317.                 Logger.codes['reset']])
  318.         return text
  319.  
  320.     
  321.     def bold(self, text):
  322.         return self.color(text, 'bold')
  323.  
  324.     
  325.     def red(self, text):
  326.         return self.color(text, 'red')
  327.  
  328.     
  329.     def green(self, text):
  330.         return self.color(text, 'green')
  331.  
  332.     
  333.     def purple(self, text):
  334.         return self.color(text, 'purple')
  335.  
  336.     
  337.     def yellow(self, text):
  338.         return self.color(text, 'yellow')
  339.  
  340.     
  341.     def darkgreen(self, text):
  342.         return self.color(text, 'darkgreen')
  343.  
  344.     
  345.     def blue(self, text):
  346.         return self.color(text, 'blue')
  347.  
  348.  
  349.